package com.example.mark.service.Impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.mark.common.Result;
import com.example.mark.entity.College;
import com.example.mark.entity.CollegeSort;
import com.example.mark.entity.ComprehensiveMark;
import com.example.mark.entity.Mark;
import com.example.mark.mapper.*;
import com.example.mark.service.CollegeService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

import java.math.BigInteger;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service // 用于服务层 注册到spring中的bean中 这样AutoWired 才可以找得到
public class CollegeServiceImpl extends ServiceImpl<CollegeMapper, College> implements CollegeService {
    @Resource //注入依赖 类似AutoWired
    private CollegeMapper collegeMapper;

    @Resource
    private CMarkMapper cMarkMapper;

    @Resource
    private ObjectMapper objectMapper;

    @Resource
    private CollegeSortMapper collegeSortMapper;

    @Resource
    private MarkMapper markMapper;

    @Resource
    private ComprehensiveMarkMapper comprehensiveMarkMapper;
    /**
     * 详情页请求1、2
     * */
    public Result selectCollegeSort(BigInteger collegeId, int sort) {

        LambdaQueryWrapper<ComprehensiveMark> lqw = new LambdaQueryWrapper<>();
        lqw.eq(ComprehensiveMark::getCollegeId, collegeId);
        ComprehensiveMark one = cMarkMapper.selectOne(lqw);

        List<CollegeSort> collegeSort = collegeMapper.selectCollegeSortByCollegeIdAndSort(collegeId, sort);

//        try {
//            // 将 one 和 collegeSort 对象转换为 JSON 字符串
//            String oneJson = objectMapper.writeValueAsString(one);
//            String collegeSortJson = objectMapper.writeValueAsString(collegeSort);
//
//            // 将两个 JSON 字符串组合成一个 JSON 对象
//            String combinedJson = String.format("{\"comprehensiveMark\": %s, \"collegeSort\": %s}", oneJson, collegeSortJson);
//
//            // 将组合后的 JSON 字符串放入 Result 对象中
//            return Result.success(combinedJson);
//        } catch (JsonProcessingException e) {
//            // 处理 JSON 转换异常
//            return Result.error("JSON conversion error: " + e.getMessage());
//        }

        try {
            // 将 one 和 collegeSort 对象转换为 JSON 字符串
            String oneJson = objectMapper.writeValueAsString(one);
            String collegeSortJson = objectMapper.writeValueAsString(collegeSort);

            // 创建一个 Map 来组合两个 JSON 对象
            Map<String, Object> combinedJsonMap = new HashMap<>();
            combinedJsonMap.put("comprehensiveMark", objectMapper.readValue(oneJson, Object.class));
            combinedJsonMap.put("collegeSort", objectMapper.readValue(collegeSortJson, Object.class));

            // 将 Map 转换为 JSON 对象
            String combinedJson = objectMapper.writeValueAsString(combinedJsonMap);

            // 将组合后的 JSON 对象放入 Result 对象中
            return Result.success(objectMapper.readValue(combinedJson, Object.class));
        } catch (JsonProcessingException e) {
            // 处理 JSON 转换异常
            return Result.error("JSON conversion error: " + e.getMessage());
        }
    }

    public boolean upvote(int collegeSortId){
        int i = collegeSortMapper.updateCollegeSortEndorse(collegeSortId);
        if(i!=0){
            return true;
        }else {
            return false;
        }
    }

    /**
     * 对学院进行评分并更新综合评分。
     *
     * @param mark 包含用户对学院的评分的Mark对象。
     * @return 如果评分和更新过程成功，则返回ComprehensiveMark对象，否则返回错误。
     */
    public Result mark(Mark mark) {
        // 计算综合评分，将各个评分相加后除以评分数量。
        float comprehensiveScore = mark.getEnviromentalRating() + mark.getFoodRating() +
                mark.getSchoolProfessionalRating() + mark.getFacilityRating();
        mark.setComprehensiveScore(comprehensiveScore / 4); // 设置综合评分

        // 设置评分的创建时间为当前日期和时间。
        mark.setCreateTime(LocalDateTime.now());

        // 创建查询包装器以查找学院的现有综合评分记录。
        LambdaQueryWrapper<ComprehensiveMark> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(ComprehensiveMark::getCollegeId, mark.getCollegeId()); // 指定学院ID的查询条件

        // 查询并获取指定学院的现有综合评分记录。
        ComprehensiveMark cm = comprehensiveMarkMapper.selectOne(lambdaQueryWrapper);

        // 获取当前评分记录的数量，并计算新旧评分的权重因子。
        float count = (float) cm.getCount();
        float num = count / (count + 1); // 现有评分的权重
        float num2 = 1 / (count + 1);    // 新评分的权重

        // 使用加权平均更新环境评分。
        cm.setEnviromentalRating(cm.getEnviromentalRating() * num + mark.getEnviromentalRating() * num2);
        // 使用加权平均更新食品评分。
        cm.setFoodRating(cm.getFoodRating() * num + mark.getFoodRating() * num2);
        // 使用加权平均更新专业评分。
        cm.setSchoolProfessionalRating(cm.getSchoolProfessionalRating() * num + mark.getSchoolProfessionalRating() * num2);
        // 使用加权平均更新设施评分。
        cm.setFacilityRating(cm.getFacilityRating() * num + mark.getFacilityRating() * num2);
        // 使用加权平均更新综合评分。
        cm.setComprehensiveScore(cm.getComprehensiveScore() * num + mark.getComprehensiveScore() * num2);
        // 更新评分记录数量。
        cm.setCount(cm.getCount() + 1);
        // 设置更新时间为当前日期和时间。
        cm.setUpdateTime(LocalDateTime.now());

        // 插入新的评分记录，并更新综合评分记录，如果两者都成功，则返回true。
        if (markMapper.insert(mark) != 0 & comprehensiveMarkMapper.updateComprehensiveMarkByCollegeId(cm) != 0) {
            return Result.success(cm);
        } else {
            return Result.error("评分失败");
        }
    }

}
